const express = require('express');
const router = express.Router();
const syncService = require('../services/SyncService');

// 同步单个包
router.post('/package', async (req, res) => {
  try {
    const { packageName } = req.body;
    if (!packageName) {
      return res.status(400).json({ error: '缺少包名' });
    }
    
    const result = await syncService.syncPackage(packageName);
    res.json(result);
  } catch (error) {
    console.error('同步包失败:', error);
    res.status(500).json({ error: error.message || '同步包失败' });
  }
});

// 批量同步包
router.post('/packages/batch', async (req, res) => {
  try {
    const { packageNames = [], limit = 10 } = req.body;
    
    if (!Array.isArray(packageNames) || packageNames.length === 0) {
      return res.status(400).json({ error: '请提供有效的包名列表' });
    }
    
    const result = await syncService.syncMultiplePackages(packageNames.slice(0, limit));
    res.json(result);
  } catch (error) {
    console.error('批量同步包失败:', error);
    res.status(500).json({ error: error.message || '批量同步包失败' });
  }
});

// 同步热门包
router.post('/popular', async (req, res) => {
  try {
    const { limit = 50 } = req.body;
    
    const result = await syncService.syncTrendingPackages();
    res.json(result);
  } catch (error) {
    console.error('同步热门包失败:', error);
    res.status(500).json({ error: error.message || '同步热门包失败' });
  }
});

// 开始全量同步任务
router.post('/start', async (req, res) => {
  try {
    const { packageNames = [], type = 'full' } = req.body;
    
    // 立即返回响应，不等待同步完成
    res.json({
      message: '同步任务已启动',
      type: packageNames.length === 0 ? 'trending' : 'custom',
      status: 'started'
    });
    
    // 异步执行同步任务
    if (packageNames.length === 0) {
      // 如果没有指定包名，同步热门包
      console.log('开始异步同步热门包...');
      syncService.syncTrendingPackages()
        .then(result => {
          console.log('热门包同步完成:', result);
        })
        .catch(error => {
          console.error('热门包同步失败:', error);
        });
    } else {
      // 同步指定的包
      console.log('开始异步同步指定包:', packageNames);
      syncService.syncMultiplePackages(packageNames)
        .then(result => {
          console.log('指定包同步完成:', result);
        })
        .catch(error => {
          console.error('指定包同步失败:', error);
        });
    }
  } catch (error) {
    console.error('启动同步任务失败:', error);
    res.status(500).json({ error: error.message || '启动同步任务失败' });
  }
});

// 获取同步状态
router.get('/status', async (req, res) => {
  try {
    const status = await syncService.getSyncStatus();
    res.json(status);
  } catch (error) {
    console.error('获取同步状态失败:', error);
    res.status(500).json({ error: error.message || '获取同步状态失败' });
  }
});

// 获取同步配置
router.get('/config', async (req, res) => {
  try {
    const config = await syncService.getSyncConfig();
    res.json(config);
  } catch (error) {
    console.error('获取同步配置失败:', error);
    res.status(500).json({ error: error.message || '获取同步配置失败' });
  }
});

// 更新同步配置
router.put('/config', async (req, res) => {
  try {
    const config = req.body;
    const result = await syncService.updateSyncConfig(config);
    res.json(result);
  } catch (error) {
    console.error('更新同步配置失败:', error);
    res.status(500).json({ error: error.message || '更新同步配置失败' });
  }
});

// 取消同步
router.post('/cancel', async (req, res) => {
  try {
    const result = await syncService.cancelSync();
    res.json(result);
  } catch (error) {
    console.error('取消同步失败:', error);
    res.status(500).json({ error: error.message || '取消同步失败' });
  }
});

// 获取同步历史
router.get('/history', async (req, res) => {
  try {
    const { status, page = 1, pageSize = 10, startDate, endDate } = req.query;
    const result = await syncService.getSyncHistory({
      status,
      page: parseInt(page),
      pageSize: parseInt(pageSize),
      startDate,
      endDate
    });
    res.json(result);
  } catch (error) {
    console.error('获取同步历史失败:', error);
    res.status(500).json({ error: error.message || '获取同步历史失败' });
  }
});

// 获取同步历史详情
router.get('/history/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const result = await syncService.getSyncHistoryDetail(id);
    res.json(result);
  } catch (error) {
    console.error('获取同步历史详情失败:', error);
    res.status(500).json({ error: error.message || '获取同步历史详情失败' });
  }
});

// 清空同步历史
router.delete('/history', async (req, res) => {
  try {
    await syncService.clearSyncHistory();
    res.json({ success: true, message: '同步历史已清空' });
  } catch (error) {
    console.error('清空同步历史失败:', error);
    res.status(500).json({ error: error.message || '清空同步历史失败' });
  }
});

module.exports = router;